home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / thinkref / archive / THINKPascalUH2.1.sea / THINKPas Univ Hdr 2.1 / Interfaces / ImageCompression.p < prev    next >
Text File  |  1995-09-14  |  34KB  |  973 lines
  1. { Converted with MPW2TPas Tuesday, September 12, 1995 7:23:07 PM }
  2. {}
  3. {     File:        ImageCompression.p}
  4. { }
  5. {     Contains:    QuickTime Image Compression Interfaces.}
  6. { }
  7. {     Version:    Technology:    QuickTime 2.0}
  8. {                 Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18}
  9. { }
  10. {     Copyright:    © 1984-1995 by Apple Computer, Inc.}
  11. {                 All rights reserved.}
  12. { }
  13. {     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter}
  14. {                 stack.  Include the file and version information (from above)}
  15. {                 in the problem description and send to:}
  16. {                     Internet:    apple.bugs@applelink.apple.com}
  17. {                     AppleLink:    APPLE.BUGS}
  18. { }
  19. {}
  20.  
  21. unit ImageCompression;
  22. interface
  23.  
  24.  
  25. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  26. {$SETC __IMAGECOMPRESSION__ := 1}
  27.  
  28.     uses
  29.         ConditionalMacros, Types, Quickdraw, QDOffscreen, Components, Controls, Windows, Dialogs, StandardFile;
  30.  
  31. { $PUSH}
  32. { $ALIGN MAC68K}
  33. { $LibExport+}
  34.  
  35.     type
  36.         MatrixRecord = record
  37.                 matrix: array[0..2, 0..2] of Fixed;
  38.             end;
  39.  
  40.         MatrixRecordPtr = ^MatrixRecord;
  41.  
  42.         FixedPoint = record
  43.                 x: Fixed;
  44.                 y: Fixed;
  45.             end;
  46.  
  47.         FixedRect = record
  48.                 left: Fixed;
  49.                 top: Fixed;
  50.                 right: Fixed;
  51.                 bottom: Fixed;
  52.             end;
  53.  
  54. { These are the bits that are set in the Component flags, and also in the codecInfo struct. }
  55.  
  56.     const
  57.         codecInfoDoes1 = $1;
  58.         codecInfoDoes2 = $2;
  59.         codecInfoDoes4 = $4;
  60.         codecInfoDoes8 = $8;
  61.         codecInfoDoes16 = $10;
  62.         codecInfoDoes32 = $20;
  63.         codecInfoDoesDither = $40;
  64.         codecInfoDoesStretch = $80;
  65.         codecInfoDoesShrink = $100;
  66.         codecInfoDoesMask = $200;
  67.         codecInfoDoesTemporal = $400;
  68.         codecInfoDoesDouble = $800;
  69.         codecInfoDoesQuad = $1000;
  70.         codecInfoDoesHalf = $2000;
  71.         codecInfoDoesQuarter = $4000;
  72.         codecInfoDoesRotate = $8000;
  73.         codecInfoDoesHorizFlip = $10000;
  74.         codecInfoDoesVertFlip = $20000;
  75.         codecInfoDoesSkew = $40000;
  76.         codecInfoDoesBlend = $80000;
  77.         codecInfoDoesWarp = $100000;
  78.         codecInfoDoesRecompress = $200000;
  79.         codecInfoDoesSpool = $400000;
  80.         codecInfoDoesRateConstrain = $800000;
  81.  
  82.         codecInfoDepth1 = $1;
  83.         codecInfoDepth2 = $2;
  84.         codecInfoDepth4 = $4;
  85.         codecInfoDepth8 = $8;
  86.         codecInfoDepth16 = $10;
  87.         codecInfoDepth32 = $20;
  88.         codecInfoDepth24 = $40;
  89.         codecInfoDepth33 = $80;
  90.         codecInfoDepth34 = $100;
  91.         codecInfoDepth36 = $200;
  92.         codecInfoDepth40 = $400;
  93.         codecInfoStoresClut = $800;
  94.         codecInfoDoesLossless = $1000;
  95.         codecInfoSequenceSensitive = $2000;
  96.  
  97.         codecFlagUseImageBuffer = $1;
  98.         codecFlagUseScreenBuffer = $2;
  99.         codecFlagUpdatePrevious = $4;
  100.         codecFlagNoScreenUpdate = $8;
  101.         codecFlagWasCompressed = $10;
  102.         codecFlagDontOffscreen = $20;
  103.         codecFlagUpdatePreviousComp = $40;
  104.         codecFlagForceKeyFrame = $80;
  105.         codecFlagOnlyScreenUpdate = $100;
  106.         codecFlagLiveGrab = $200;
  107.         codecFlagDontUseNewImageBuffer = $400;
  108.         codecFlagInterlaceUpdate = $800;
  109.         codecFlagCatchUpDiff = $1000;
  110.         codecFlagUsedNewImageBuffer = $4000;
  111.         codecFlagUsedImageBuffer = $8000;
  112.  
  113. { The minimum data size for spooling in or out data }
  114.         codecMinimumDataSize = 32768;
  115.  
  116.         compressorComponentType = 'imco';                        { the type for "Components" which compress images }
  117.         decompressorComponentType = 'imdc';
  118.  
  119.  
  120.     type
  121.         CompressorComponent = Component;
  122.  
  123.         DecompressorComponent = Component;
  124.  
  125.         CodecComponent = Component;
  126.  
  127.  
  128.     const
  129.         anyCodec = 0;                            { take first working codec of given type }
  130.         bestSpeedCodec = -1;                            { take fastest codec of given type }
  131.         bestFidelityCodec = -2;                            { take codec which is most accurate }
  132.         bestCompressionCodec = -3;                            { take codec of given type that is most accurate }
  133.  
  134.  
  135.     type
  136.         CodecType = LONGINT;
  137.  
  138.         CodecFlags = INTEGER;
  139.  
  140.         CodecQ = LONGINT;
  141.  
  142.  
  143.     const
  144.         codecLosslessQuality = $400;
  145.         codecMaxQuality = $3ff;
  146.         codecMinQuality = $000;
  147.         codecLowQuality = $100;
  148.         codecNormalQuality = $200;
  149.         codecHighQuality = $300;
  150.  
  151.         codecCompletionSource = $1;                { asynchronous codec is done with source data }
  152.         codecCompletionDest = $2;                { asynchronous codec is done with destination data }
  153.  
  154.         codecProgressOpen = 0;
  155.         codecProgressUpdatePercent = 1;
  156.         codecProgressClose = 2;
  157.  
  158.     type
  159.         ICMDataProcPtr = ProcPtr;  { FUNCTION ICMData(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT): OSErr; }
  160.         ICMFlushProcPtr = ProcPtr;  { FUNCTION ICMFlush(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT): OSErr; }
  161.         ICMCompletionProcPtr = ProcPtr;  { PROCEDURE ICMCompletion(result: OSErr; flags: INTEGER; refcon: LONGINT); }
  162.         ICMProgressProcPtr = ProcPtr;  { FUNCTION ICMProgress(message: INTEGER; completeness: Fixed; refcon: LONGINT): OSErr; }
  163.         StdPixProcPtr = ProcPtr;  { PROCEDURE StdPix(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER); }
  164.         ICMAlignmentProcPtr = ProcPtr;  { PROCEDURE ICMAlignment(VAR rp: Rect; refcon: LONGINT); }
  165.         ICMDataUPP = UniversalProcPtr;
  166.         ICMFlushUPP = UniversalProcPtr;
  167.         ICMCompletionUPP = UniversalProcPtr;
  168.         ICMProgressUPP = UniversalProcPtr;
  169.         StdPixUPP = UniversalProcPtr;
  170.         ICMAlignmentUPP = UniversalProcPtr;
  171.  
  172.         ImageSequence = LONGINT;
  173.  
  174.         ICMProgressProcRecord = record
  175.                 progressProc: ICMProgressUPP;
  176.                 progressRefCon: LONGINT;
  177.             end;
  178.  
  179.         ICMProgressProcRecordPtr = ^ICMProgressProcRecord;
  180.  
  181.         ICMCompletionProcRecord = record
  182.                 completionProc: ICMCompletionUPP;
  183.                 completionRefCon: LONGINT;
  184.             end;
  185.  
  186.         ICMCompletionProcRecordPtr = ^ICMCompletionProcRecord;
  187.  
  188.         ICMDataProcRecord = record
  189.                 dataProc: ICMDataUPP;
  190.                 dataRefCon: LONGINT;
  191.             end;
  192.  
  193.         ICMDataProcRecordPtr = ^ICMDataProcRecord;
  194.  
  195.         ICMFlushProcRecord = record
  196.                 flushProc: ICMFlushUPP;
  197.                 flushRefCon: LONGINT;
  198.             end;
  199.  
  200.         ICMFlushProcRecordPtr = ^ICMFlushProcRecord;
  201.  
  202.         ICMAlignmentProcRecord = record
  203.                 alignmentProc: ICMAlignmentUPP;
  204.                 alignmentRefCon: LONGINT;
  205.             end;
  206.  
  207.         ICMAlignmentProcRecordPtr = ^ICMAlignmentProcRecord;
  208.  
  209.         DataRateParams = record
  210.                 dataRate: LONGINT;
  211.                 dataOverrun: LONGINT;
  212.                 frameDuration: LONGINT;
  213.                 keyFrameRate: LONGINT;
  214.                 minSpatialQuality: CodecQ;
  215.                 minTemporalQuality: CodecQ;
  216.             end;
  217.  
  218.         DataRateParamsPtr = ^DataRateParams;
  219.  
  220.         ImageDescription = packed record
  221.                 idSize: LONGINT;                                { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
  222.                 cType: CodecType;                                { what kind of codec compressed this data }
  223.                 resvd1: LONGINT;                                { reserved for Apple use }
  224.                 resvd2: INTEGER;                                { reserved for Apple use }
  225.                 dataRefIndex: INTEGER;                                { set to zero  }
  226.                 version: INTEGER;                                { which version is this data }
  227.                 revisionLevel: INTEGER;                                { what version of that codec did this }
  228.                 vendor: LONGINT;                                { whose  codec compressed this data }
  229.                 temporalQuality: CodecQ;                                    { what was the temporal quality factor  }
  230.                 spatialQuality: CodecQ;                                    { what was the spatial quality factor }
  231.                 width: INTEGER;                                { how many pixels wide is this data }
  232.                 height: INTEGER;                                { how many pixels high is this data }
  233.                 hRes: Fixed;                                    { horizontal resolution }
  234.                 vRes: Fixed;                                    { vertical resolution }
  235.                 dataSize: LONGINT;                                { if known, the size of data for this image descriptor }
  236.                 frameCount: INTEGER;                                { number of frames this description applies to }
  237.                 name: Str31;                                    { name of codec ( in case not installed )  }
  238.                 depth: INTEGER;                                { what depth is this data (1-32) or ( 33-40 grayscale ) }
  239.                 clutID: INTEGER;                                { clut id or if 0 clut follows  or -1 if no clut }
  240.             end;
  241.  
  242.         ImageDescriptionPtr = ^ImageDescription;
  243.         ImageDescriptionHandle = ^ImageDescriptionPtr;
  244.  
  245.         CodecInfo = packed record
  246.                 typeName: Str31;                                    { name of the codec type i.e.: 'Apple Image Compression' }
  247.                 version: INTEGER;                                { version of the codec data that this codec knows about }
  248.                 revisionLevel: INTEGER;                                { revision level of this codec i.e: 0x00010001 (1.0.1) }
  249.                 vendor: LONGINT;                                { Maker of this codec i.e: 'appl' }
  250.                 decompressFlags: LONGINT;                                { codecInfo flags for decompression capabilities }
  251.                 compressFlags: LONGINT;                                { codecInfo flags for compression capabilities }
  252.                 formatFlags: LONGINT;                                { codecInfo flags for compression format details }
  253.                 compressionAccuracy: UInt8;                                    { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
  254.                 decompressionAccuracy: UInt8;                                    { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
  255.                 compressionSpeed: INTEGER;                                { ( millisecs for compressing 320x240 on base mac II) (0 if unknown)  }
  256.                 decompressionSpeed: INTEGER;                                { ( millisecs for decompressing 320x240 on mac II)(0 if unknown)  }
  257.                 compressionLevel: UInt8;                                    { measure (1-255) of compression level of this codec (0 if unknown)  }
  258.                 resvd: UInt8;                                    { pad }
  259.                 minimumHeight: INTEGER;                                { minimum height of image (block size) }
  260.                 minimumWidth: INTEGER;                                { minimum width of image (block size) }
  261.                 decompressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  262.                 compressPipelineLatency: INTEGER;                                { in milliseconds ( for asynchronous codecs ) }
  263.                 privateData: LONGINT;
  264.             end;
  265.  
  266.         CodecNameSpec = record
  267.                 codec: CodecComponent;
  268.                 cType: CodecType;
  269.                 typeName: Str31;
  270.                 name: Handle;
  271.             end;
  272.  
  273.         CodecNameSpecList = record
  274.                 count: INTEGER;
  275.                 list: array[0..0] of CodecNameSpec;
  276.             end;
  277.  
  278.         CodecNameSpecListPtr = ^CodecNameSpecList;
  279.  
  280.  
  281.     const
  282.         defaultDither = 0;
  283.         forceDither = 1;
  284.         suppressDither = 2;
  285.         useColorMatching = 4;
  286.  
  287.  
  288.     type
  289.         ICMFrameTimeRecord = record
  290.                 value: wide;                                    { frame time}
  291.                 scale: LONGINT;                                { timescale of value/duration fields}
  292.                 base: Ptr;                                    { timebase}
  293.                 duration: LONGINT;                                { duration frame is to be displayed (0 if unknown)}
  294.                 rate: Fixed;                                    { rate of timebase relative to wall-time}
  295.             end;
  296.  
  297.         ICMFrameTimePtr = ^ICMFrameTimeRecord;
  298.  
  299.  
  300.     const
  301.         uppICMDataProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  302.         uppICMFlushProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  303.         uppICMCompletionProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  304.         uppICMProgressProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  305.         uppStdPixProcInfo = $002FEFC0; { PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param); }
  306.         uppICMAlignmentProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  307.  
  308.     function NewICMDataProc (userRoutine: ICMDataProcPtr): ICMDataUPP;
  309.     {$IFC NOT GENERATINGCFM }
  310.     inline
  311.         $2E9F;
  312.     {$ENDC}
  313.  
  314.     function NewICMFlushProc (userRoutine: ICMFlushProcPtr): ICMFlushUPP;
  315.     {$IFC NOT GENERATINGCFM }
  316.     inline
  317.         $2E9F;
  318.     {$ENDC}
  319.  
  320.     function NewICMCompletionProc (userRoutine: ICMCompletionProcPtr): ICMCompletionUPP;
  321.     {$IFC NOT GENERATINGCFM }
  322.     inline
  323.         $2E9F;
  324.     {$ENDC}
  325.  
  326.     function NewICMProgressProc (userRoutine: ICMProgressProcPtr): ICMProgressUPP;
  327.     {$IFC NOT GENERATINGCFM }
  328.     inline
  329.         $2E9F;
  330.     {$ENDC}
  331.  
  332.     function NewStdPixProc (userRoutine: StdPixProcPtr): StdPixUPP;
  333.     {$IFC NOT GENERATINGCFM }
  334.     inline
  335.         $2E9F;
  336.     {$ENDC}
  337.  
  338.     function NewICMAlignmentProc (userRoutine: ICMAlignmentProcPtr): ICMAlignmentUPP;
  339.     {$IFC NOT GENERATINGCFM }
  340.     inline
  341.         $2E9F;
  342.     {$ENDC}
  343.  
  344.     function CallICMDataProc (var dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT; userRoutine: ICMDataUPP): OSErr;
  345.     {$IFC NOT GENERATINGCFM}
  346.     inline
  347.         $205F, $4E90;
  348.     {$ENDC}
  349.  
  350.     function CallICMFlushProc (data: Ptr; bytesAdded: LONGINT; refcon: LONGINT; userRoutine: ICMFlushUPP): OSErr;
  351.     {$IFC NOT GENERATINGCFM}
  352.     inline
  353.         $205F, $4E90;
  354.     {$ENDC}
  355.  
  356.     procedure CallICMCompletionProc (result: OSErr; flags: INTEGER; refcon: LONGINT; userRoutine: ICMCompletionUPP);
  357.     {$IFC NOT GENERATINGCFM}
  358.     inline
  359.         $205F, $4E90;
  360.     {$ENDC}
  361.  
  362.     function CallICMProgressProc (message: INTEGER; completeness: Fixed; refcon: LONGINT; userRoutine: ICMProgressUPP): OSErr;
  363.     {$IFC NOT GENERATINGCFM}
  364.     inline
  365.         $205F, $4E90;
  366.     {$ENDC}
  367.  
  368.     procedure CallStdPixProc (var src: PixMap; var srcRect: Rect; var matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; var matte: PixMap; var matteRect: Rect; flags: INTEGER; userRoutine: StdPixUPP);
  369.     {$IFC NOT GENERATINGCFM}
  370.     inline
  371.         $205F, $4E90;
  372.     {$ENDC}
  373.  
  374.     procedure CallICMAlignmentProc (var rp: Rect; refcon: LONGINT; userRoutine: ICMAlignmentUPP);
  375.     {$IFC NOT GENERATINGCFM}
  376.     inline
  377.         $205F, $4E90;
  378.     {$ENDC}
  379.  
  380.     function CodecManagerVersion (var version: LONGINT): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     inline
  383.         $7000, $AAA3;
  384.     {$ENDC}
  385.     function GetCodecNameList (var list: CodecNameSpecListPtr; showAll: INTEGER): OSErr;
  386.     {$IFC NOT GENERATINGCFM}
  387.     inline
  388.         $7001, $AAA3;
  389.     {$ENDC}
  390.     function DisposeCodecNameList (list: CodecNameSpecListPtr): OSErr;
  391.     {$IFC NOT GENERATINGCFM}
  392.     inline
  393.         $700F, $AAA3;
  394.     {$ENDC}
  395.     function GetCodecInfo (var info: CodecInfo; cType: CodecType; codec: CodecComponent): OSErr;
  396.     {$IFC NOT GENERATINGCFM}
  397.     inline
  398.         $7003, $AAA3;
  399.     {$ENDC}
  400.     function GetMaxCompressionSize (src: PixMapHandle; {CONST}
  401.                                     var srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; var size: LONGINT): OSErr;
  402.     {$IFC NOT GENERATINGCFM}
  403.     inline
  404.         $7004, $AAA3;
  405.     {$ENDC}
  406.     function GetCompressionTime (src: PixMapHandle; {CONST}
  407.                                     var srcRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; var spatialQuality: CodecQ; var temporalQuality: CodecQ; var compressTime: LONGINT): OSErr;
  408.     {$IFC NOT GENERATINGCFM}
  409.     inline
  410.         $7005, $AAA3;
  411.     {$ENDC}
  412.     function CompressImage (src: PixMapHandle; {CONST}
  413.                                     var srcRect: Rect; quality: CodecQ; cType: CodecType; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  414.     {$IFC NOT GENERATINGCFM}
  415.     inline
  416.         $7006, $AAA3;
  417.     {$ENDC}
  418.     function FCompressImage (src: PixMapHandle; {CONST}
  419.                                     var srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; clut: CTabHandle; flags: CodecFlags; bufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; progressProc: ICMProgressProcRecordPtr; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  420.     {$IFC NOT GENERATINGCFM}
  421.     inline
  422.         $7007, $AAA3;
  423.     {$ENDC}
  424.     function DecompressImage (data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}
  425.                                     var srcRect: Rect; {CONST}
  426.                                     var dstRect: Rect; mode: INTEGER; mask: RgnHandle): OSErr;
  427.     {$IFC NOT GENERATINGCFM}
  428.     inline
  429.         $7008, $AAA3;
  430.     {$ENDC}
  431.     function FDecompressImage (data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}
  432.                                     var srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapHandle; {CONST}
  433.                                     var matteRect: Rect; accuracy: CodecQ; codec: DecompressorComponent; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  434.     {$IFC NOT GENERATINGCFM}
  435.     inline
  436.         $7009, $AAA3;
  437.     {$ENDC}
  438.     function CompressSequenceBegin (var seqID: ImageSequence; src: PixMapHandle; prev: PixMapHandle; {CONST}
  439.                                     var srcRect: Rect; {CONST}
  440.                                     var prevRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT; clut: CTabHandle; flags: CodecFlags; desc: ImageDescriptionHandle): OSErr;
  441.     {$IFC NOT GENERATINGCFM}
  442.     inline
  443.         $700A, $AAA3;
  444.     {$ENDC}
  445.     function CompressSequenceFrame (seqID: ImageSequence; src: PixMapHandle; {CONST}
  446.                                     var srcRect: Rect; flags: CodecFlags; data: Ptr; var dataSize: LONGINT; var similarity: UInt8; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  447.     {$IFC NOT GENERATINGCFM}
  448.     inline
  449.         $700B, $AAA3;
  450.     {$ENDC}
  451.     function DecompressSequenceBegin (var seqID: ImageSequence; desc: ImageDescriptionHandle; port: CGrafPtr; gdh: GDHandle; {CONST}
  452.                                     var srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  453.     {$IFC NOT GENERATINGCFM}
  454.     inline
  455.         $700D, $AAA3;
  456.     {$ENDC}
  457.     function DecompressSequenceBeginS (var seqID: ImageSequence; desc: ImageDescriptionHandle; data: Ptr; dataSize: LONGINT; port: CGrafPtr; gdh: GDHandle; {CONST}
  458.                                     var srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  459.     {$IFC NOT GENERATINGCFM}
  460.     inline
  461.         $203C, $30, $5D, $AAA3;
  462.     {$ENDC}
  463.     function DecompressSequenceFrame (seqID: ImageSequence; data: Ptr; inFlags: CodecFlags; var outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  464.     {$IFC NOT GENERATINGCFM}
  465.     inline
  466.         $700E, $AAA3;
  467.     {$ENDC}
  468.     function DecompressSequenceFrameS (seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; var outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  469.     {$IFC NOT GENERATINGCFM}
  470.     inline
  471.         $203C, $16, $47, $AAA3;
  472.     {$ENDC}
  473.     function DecompressSequenceFrameWhen (seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; var outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr; {CONST}
  474.                                     var frameTime: ICMFrameTimeRecord): OSErr;
  475.     {$IFC NOT GENERATINGCFM}
  476.     inline
  477.         $203C, $1A, $5E, $AAA3;
  478.     {$ENDC}
  479.     function CDSequenceFlush (seqID: ImageSequence): OSErr;
  480.     {$IFC NOT GENERATINGCFM}
  481.     inline
  482.         $203C, $4, $5F, $AAA3;
  483.     {$ENDC}
  484.     function SetDSequenceMatrix (seqID: ImageSequence; matrix: MatrixRecordPtr): OSErr;
  485.     {$IFC NOT GENERATINGCFM}
  486.     inline
  487.         $7010, $AAA3;
  488.     {$ENDC}
  489.     function SetDSequenceMatte (seqID: ImageSequence; matte: PixMapHandle; {CONST}
  490.                                     var matteRect: Rect): OSErr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     inline
  493.         $7011, $AAA3;
  494.     {$ENDC}
  495.     function SetDSequenceMask (seqID: ImageSequence; mask: RgnHandle): OSErr;
  496.     {$IFC NOT GENERATINGCFM}
  497.     inline
  498.         $7012, $AAA3;
  499.     {$ENDC}
  500.     function SetDSequenceTransferMode (seqID: ImageSequence; mode: INTEGER; {CONST}
  501.                                     var opColor: RGBColor): OSErr;
  502.     {$IFC NOT GENERATINGCFM}
  503.     inline
  504.         $7013, $AAA3;
  505.     {$ENDC}
  506.     function SetDSequenceDataProc (seqID: ImageSequence; dataProc: ICMDataProcRecordPtr; bufferSize: LONGINT): OSErr;
  507.     {$IFC NOT GENERATINGCFM}
  508.     inline
  509.         $7014, $AAA3;
  510.     {$ENDC}
  511.     function SetDSequenceAccuracy (seqID: ImageSequence; accuracy: CodecQ): OSErr;
  512.     {$IFC NOT GENERATINGCFM}
  513.     inline
  514.         $7034, $AAA3;
  515.     {$ENDC}
  516.     function SetDSequenceSrcRect (seqID: ImageSequence; {CONST}
  517.                                     var srcRect: Rect): OSErr;
  518.     {$IFC NOT GENERATINGCFM}
  519.     inline
  520.         $7035, $AAA3;
  521.     {$ENDC}
  522.     function GetDSequenceImageBuffer (seqID: ImageSequence; var gworld: GWorldPtr): OSErr;
  523.     {$IFC NOT GENERATINGCFM}
  524.     inline
  525.         $7015, $AAA3;
  526.     {$ENDC}
  527.     function GetDSequenceScreenBuffer (seqID: ImageSequence; var gworld: GWorldPtr): OSErr;
  528.     {$IFC NOT GENERATINGCFM}
  529.     inline
  530.         $7016, $AAA3;
  531.     {$ENDC}
  532.     function SetCSequenceQuality (seqID: ImageSequence; spatialQuality: CodecQ; temporalQuality: CodecQ): OSErr;
  533.     {$IFC NOT GENERATINGCFM}
  534.     inline
  535.         $7017, $AAA3;
  536.     {$ENDC}
  537.     function SetCSequencePrev (seqID: ImageSequence; prev: PixMapHandle; {CONST}
  538.                                     var prevRect: Rect): OSErr;
  539.     {$IFC NOT GENERATINGCFM}
  540.     inline
  541.         $7018, $AAA3;
  542.     {$ENDC}
  543.     function SetCSequenceFlushProc (seqID: ImageSequence; flushProc: ICMFlushProcRecordPtr; bufferSize: LONGINT): OSErr;
  544.     {$IFC NOT GENERATINGCFM}
  545.     inline
  546.         $7033, $AAA3;
  547.     {$ENDC}
  548.     function SetCSequenceKeyFrameRate (seqID: ImageSequence; keyframerate: LONGINT): OSErr;
  549.     {$IFC NOT GENERATINGCFM}
  550.     inline
  551.         $7036, $AAA3;
  552.     {$ENDC}
  553.     function GetCSequenceKeyFrameRate (seqID: ImageSequence; var keyframerate: LONGINT): OSErr;
  554.     {$IFC NOT GENERATINGCFM}
  555.     inline
  556.         $203C, $8, $4B, $AAA3;
  557.     {$ENDC}
  558.     function GetCSequencePrevBuffer (seqID: ImageSequence; var gworld: GWorldPtr): OSErr;
  559.     {$IFC NOT GENERATINGCFM}
  560.     inline
  561.         $7019, $AAA3;
  562.     {$ENDC}
  563.     function CDSequenceBusy (seqID: ImageSequence): OSErr;
  564.     {$IFC NOT GENERATINGCFM}
  565.     inline
  566.         $701A, $AAA3;
  567.     {$ENDC}
  568.     function CDSequenceEnd (seqID: ImageSequence): OSErr;
  569.     {$IFC NOT GENERATINGCFM}
  570.     inline
  571.         $701B, $AAA3;
  572.     {$ENDC}
  573.     function GetCompressedImageSize (desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; var dataSize: LONGINT): OSErr;
  574.     {$IFC NOT GENERATINGCFM}
  575.     inline
  576.         $701C, $AAA3;
  577.     {$ENDC}
  578.     function GetSimilarity (src: PixMapHandle; {CONST}
  579.                                     var srcRect: Rect; desc: ImageDescriptionHandle; data: Ptr; var similarity: Fixed): OSErr;
  580.     {$IFC NOT GENERATINGCFM}
  581.     inline
  582.         $701D, $AAA3;
  583.     {$ENDC}
  584.     function GetImageDescriptionCTable (desc: ImageDescriptionHandle; var ctable: CTabHandle): OSErr;
  585.     {$IFC NOT GENERATINGCFM}
  586.     inline
  587.         $701E, $AAA3;
  588.     {$ENDC}
  589.     function SetImageDescriptionCTable (desc: ImageDescriptionHandle; ctable: CTabHandle): OSErr;
  590.     {$IFC NOT GENERATINGCFM}
  591.     inline
  592.         $701F, $AAA3;
  593.     {$ENDC}
  594.     function GetImageDescriptionExtension (desc: ImageDescriptionHandle; var extension: Handle; idType: LONGINT; index: LONGINT): OSErr;
  595.     {$IFC NOT GENERATINGCFM}
  596.     inline
  597.         $7020, $AAA3;
  598.     {$ENDC}
  599.     function SetImageDescriptionExtension (desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  600.     {$IFC NOT GENERATINGCFM}
  601.     inline
  602.         $7021, $AAA3;
  603.     {$ENDC}
  604.     function RemoveImageDescriptionExtension (var desc: ImageDescription; idType: LONGINT; index: LONGINT): OSErr;
  605.     {$IFC NOT GENERATINGCFM}
  606.     inline
  607.         $203C, $C, $3A, $AAA3;
  608.     {$ENDC}
  609.     function CountImageDescriptionExtensionType (var desc: ImageDescription; idType: LONGINT; var count: LONGINT): OSErr;
  610.     {$IFC NOT GENERATINGCFM}
  611.     inline
  612.         $203C, $C, $3B, $AAA3;
  613.     {$ENDC}
  614.     function GetNextImageDescriptionExtensionType (var desc: ImageDescription; var idType: LONGINT): OSErr;
  615.     {$IFC NOT GENERATINGCFM}
  616.     inline
  617.         $203C, $8, $3C, $AAA3;
  618.     {$ENDC}
  619.     function FindCodec (cType: CodecType; specCodec: CodecComponent; var compressor: CompressorComponent; var decompressor: DecompressorComponent): OSErr;
  620.     {$IFC NOT GENERATINGCFM}
  621.     inline
  622.         $7023, $AAA3;
  623.     {$ENDC}
  624.     function CompressPicture (srcPicture: PicHandle; dstPicture: PicHandle; quality: CodecQ; cType: CodecType): OSErr;
  625.     {$IFC NOT GENERATINGCFM}
  626.     inline
  627.         $7024, $AAA3;
  628.     {$ENDC}
  629.     function FCompressPicture (srcPicture: PicHandle; dstPicture: PicHandle; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  630.     {$IFC NOT GENERATINGCFM}
  631.     inline
  632.         $7025, $AAA3;
  633.     {$ENDC}
  634.     function CompressPictureFile (srcRefNum: INTEGER; dstRefNum: INTEGER; quality: CodecQ; cType: CodecType): OSErr;
  635.     {$IFC NOT GENERATINGCFM}
  636.     inline
  637.         $7026, $AAA3;
  638.     {$ENDC}
  639.     function FCompressPictureFile (srcRefNum: INTEGER; dstRefNum: INTEGER; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  640.     {$IFC NOT GENERATINGCFM}
  641.     inline
  642.         $7027, $AAA3;
  643.     {$ENDC}
  644.     function GetPictureFileHeader (refNum: INTEGER; var frame: Rect; var header: OpenCPicParams): OSErr;
  645.     {$IFC NOT GENERATINGCFM}
  646.     inline
  647.         $7028, $AAA3;
  648.     {$ENDC}
  649.     function DrawPictureFile (refNum: INTEGER; {CONST}
  650.                                     var frame: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  651.     {$IFC NOT GENERATINGCFM}
  652.     inline
  653.         $7029, $AAA3;
  654.     {$ENDC}
  655.     function DrawTrimmedPicture (srcPicture: PicHandle; {CONST}
  656.                                     var frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  657.     {$IFC NOT GENERATINGCFM}
  658.     inline
  659.         $702E, $AAA3;
  660.     {$ENDC}
  661.     function DrawTrimmedPictureFile (srcRefnum: INTEGER; {CONST}
  662.                                     var frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  663.     {$IFC NOT GENERATINGCFM}
  664.     inline
  665.         $702F, $AAA3;
  666.     {$ENDC}
  667.     function MakeThumbnailFromPicture (picture: PicHandle; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  668.     {$IFC NOT GENERATINGCFM}
  669.     inline
  670.         $702A, $AAA3;
  671.     {$ENDC}
  672.     function MakeThumbnailFromPictureFile (refNum: INTEGER; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  673.     {$IFC NOT GENERATINGCFM}
  674.     inline
  675.         $702B, $AAA3;
  676.     {$ENDC}
  677.     function MakeThumbnailFromPixMap (src: PixMapHandle; {CONST}
  678.                                     var srcRect: Rect; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  679.     {$IFC NOT GENERATINGCFM}
  680.     inline
  681.         $702C, $AAA3;
  682.     {$ENDC}
  683.     function TrimImage (desc: ImageDescriptionHandle; inData: Ptr; inBufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; outData: Ptr; outBufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; var trimRect: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  684.     {$IFC NOT GENERATINGCFM}
  685.     inline
  686.         $702D, $AAA3;
  687.     {$ENDC}
  688.     function ConvertImage (srcDD: ImageDescriptionHandle; srcData: Ptr; colorDepth: INTEGER; clut: CTabHandle; accuracy: CodecQ; quality: CodecQ; cType: CodecType; codec: CodecComponent; dstDD: ImageDescriptionHandle; dstData: Ptr): OSErr;
  689.     {$IFC NOT GENERATINGCFM}
  690.     inline
  691.         $7030, $AAA3;
  692.     {$ENDC}
  693.     function GetCompressedPixMapInfo (pix: PixMapPtr; var desc: ImageDescriptionHandle; var data: Ptr; var bufferSize: LONGINT; var dataProc: ICMDataProcRecord; var progressProc: ICMProgressProcRecord): OSErr;
  694.     {$IFC NOT GENERATINGCFM}
  695.     inline
  696.         $7037, $AAA3;
  697.     {$ENDC}
  698.     function SetCompressedPixMapInfo (pix: PixMapPtr; desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  699.     {$IFC NOT GENERATINGCFM}
  700.     inline
  701.         $7038, $AAA3;
  702.     {$ENDC}
  703.     procedure StdPix (src: PixMapPtr; {CONST}
  704.                                     var srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapPtr; {CONST}
  705.                                     var matteRect: Rect; flags: INTEGER);
  706.     {$IFC NOT GENERATINGCFM}
  707.     inline
  708.         $700C, $AAA3;
  709.     {$ENDC}
  710.     function TransformRgn (matrix: MatrixRecordPtr; rgn: RgnHandle): OSErr;
  711.     {$IFC NOT GENERATINGCFM}
  712.     inline
  713.         $7039, $AAA3;
  714.     {$ENDC}
  715. {**********}
  716. {    preview stuff}
  717. {**********}
  718.     procedure SFGetFilePreview (where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; var reply: SFReply);
  719.     {$IFC NOT GENERATINGCFM}
  720.     inline
  721.         $7041, $AAA3;
  722.     {$ENDC}
  723.     procedure SFPGetFilePreview (where: Point; prompt: ConstStr255Param; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; var reply: SFReply; dlgID: INTEGER; filterProc: ModalFilterUPP);
  724.     {$IFC NOT GENERATINGCFM}
  725.     inline
  726.         $7042, $AAA3;
  727.     {$ENDC}
  728.     procedure StandardGetFilePreview (fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; var reply: StandardFileReply);
  729.     {$IFC NOT GENERATINGCFM}
  730.     inline
  731.         $7043, $AAA3;
  732.     {$ENDC}
  733.     procedure CustomGetFilePreview (fileFilter: FileFilterYDUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; var reply: StandardFileReply; dlgID: INTEGER; where: Point; dlgHook: DlgHookYDUPP; filterProc: ModalFilterYDUPP; activeList: ActivationOrderListPtr; activateProc: ActivateYDUPP; yourDataPtr: univ Ptr);
  734.     {$IFC NOT GENERATINGCFM}
  735.     inline
  736.         $7044, $AAA3;
  737.     {$ENDC}
  738.     function MakeFilePreview (resRefNum: INTEGER; progress: ICMProgressProcRecordPtr): OSErr;
  739.     {$IFC NOT GENERATINGCFM}
  740.     inline
  741.         $7045, $AAA3;
  742.     {$ENDC}
  743.     function AddFilePreview (resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
  744.     {$IFC NOT GENERATINGCFM}
  745.     inline
  746.         $7046, $AAA3;
  747.     {$ENDC}
  748.  
  749.     const
  750.         sfpItemPreviewAreaUser = 11;
  751.         sfpItemPreviewStaticText = 12;
  752.         sfpItemPreviewDividerUser = 13;
  753.         sfpItemCreatePreviewButton = 14;
  754.         sfpItemShowPreviewButton = 15;
  755.  
  756.  
  757.     type
  758.         PreviewResourceRecord = record
  759.                 modDate: LONGINT;
  760.                 version: INTEGER;
  761.                 resType: OSType;
  762.                 resID: INTEGER;
  763.             end;
  764.  
  765.         PreviewResourcePtr = ^PreviewResourceRecord;
  766.         PreviewResource = ^PreviewResourcePtr;
  767.  
  768.  
  769.     procedure AlignScreenRect (var rp: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  770.     {$IFC NOT GENERATINGCFM}
  771.     inline
  772.         $203C, $8, $4C, $AAA3;
  773.     {$ENDC}
  774.     procedure AlignWindow (wp: WindowPtr; front: BOOLEAN; {CONST}
  775.                                     var alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  776.     {$IFC NOT GENERATINGCFM}
  777.     inline
  778.         $203C, $E, $4D, $AAA3;
  779.     {$ENDC}
  780.     procedure DragAlignedWindow (wp: WindowPtr; startPt: Point; var boundsRect: Rect; var alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  781.     {$IFC NOT GENERATINGCFM}
  782.     inline
  783.         $203C, $14, $4E, $AAA3;
  784.     {$ENDC}
  785.     function DragAlignedGrayRgn (theRgn: RgnHandle; startPt: Point; var boundsRect: Rect; var slopRect: Rect; axis: INTEGER; actionProc: UniversalProcPtr; var alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr): LONGINT;
  786.     {$IFC NOT GENERATINGCFM}
  787.     inline
  788.         $203C, $1E, $4F, $AAA3;
  789.     {$ENDC}
  790.     function SetCSequenceDataRateParams (seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  791.     {$IFC NOT GENERATINGCFM}
  792.     inline
  793.         $203C, $8, $50, $AAA3;
  794.     {$ENDC}
  795.     function SetCSequenceFrameNumber (seqID: ImageSequence; frameNumber: LONGINT): OSErr;
  796.     {$IFC NOT GENERATINGCFM}
  797.     inline
  798.         $203C, $8, $51, $AAA3;
  799.     {$ENDC}
  800.     function NewImageGWorld (var gworld: GWorldPtr; idh: ImageDescriptionHandle; flags: GWorldFlags): QDErr;
  801.     {$IFC NOT GENERATINGCFM}
  802.     inline
  803.         $203C, $C, $52, $AAA3;
  804.     {$ENDC}
  805.     function GetCSequenceDataRateParams (seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  806.     {$IFC NOT GENERATINGCFM}
  807.     inline
  808.         $203C, $8, $53, $AAA3;
  809.     {$ENDC}
  810.     function GetCSequenceFrameNumber (seqID: ImageSequence; var frameNumber: LONGINT): OSErr;
  811.     {$IFC NOT GENERATINGCFM}
  812.     inline
  813.         $203C, $8, $54, $AAA3;
  814.     {$ENDC}
  815.     function GetBestDeviceRect (var gdh: GDHandle; var rp: Rect): OSErr;
  816.     {$IFC NOT GENERATINGCFM}
  817.     inline
  818.         $203C, $8, $55, $AAA3;
  819.     {$ENDC}
  820.     function SetSequenceProgressProc (seqID: ImageSequence; var progressProc: ICMProgressProcRecord): OSErr;
  821.     {$IFC NOT GENERATINGCFM}
  822.     inline
  823.         $203C, $8, $56, $AAA3;
  824.     {$ENDC}
  825.     function GDHasScale (gdh: GDHandle; depth: INTEGER; var scale: Fixed): OSErr;
  826.     {$IFC NOT GENERATINGCFM}
  827.     inline
  828.         $203C, $A, $5A, $AAA3;
  829.     {$ENDC}
  830.     function GDGetScale (gdh: GDHandle; var scale: Fixed; var flags: INTEGER): OSErr;
  831.     {$IFC NOT GENERATINGCFM}
  832.     inline
  833.         $203C, $C, $5B, $AAA3;
  834.     {$ENDC}
  835.     function GDSetScale (gdh: GDHandle; scale: Fixed; flags: INTEGER): OSErr;
  836.     {$IFC NOT GENERATINGCFM}
  837.     inline
  838.         $203C, $A, $5C, $AAA3;
  839.     {$ENDC}
  840.     function ICMShieldSequenceCursor (seqID: ImageSequence): OSErr;
  841.     {$IFC NOT GENERATINGCFM}
  842.     inline
  843.         $203C, $4, $62, $AAA3;
  844.     {$ENDC}
  845.     procedure ICMDecompressComplete (seqID: ImageSequence; err: OSErr; flag: INTEGER; completionRtn: ICMCompletionProcRecordPtr);
  846.     {$IFC NOT GENERATINGCFM}
  847.     inline
  848.         $203C, $C, $63, $AAA3;
  849.     {$ENDC}
  850.     function SetDSequenceTimeCode (seqID: ImageSequence; timeCodeFormat: univ Ptr; timeCodeTime: univ Ptr): OSErr;
  851.     {$IFC NOT GENERATINGCFM}
  852.     inline
  853.         $203C, $C, $64, $AAA3;
  854.     {$ENDC}
  855.  
  856.     const
  857.         identityMatrixType = $00;                            { result if matrix is identity }
  858.         translateMatrixType = $01;                            { result if matrix translates }
  859.         scaleMatrixType = $02;                            { result if matrix scales }
  860.         scaleTranslateMatrixType = $03;                            { result if matrix scales and translates }
  861.         linearMatrixType = $04;                            { result if matrix is general 2 x 2 }
  862.         linearTranslateMatrixType = $05;                            { result if matrix is general 2 x 2 and translates }
  863.         perspectiveMatrixType = $06;                            { result if matrix is general 3 x 3 }
  864.  
  865.  
  866.     type
  867.         MatrixFlags = INTEGER;
  868.  
  869.  
  870.     function GetMatrixType ({CONST}
  871.                                     var m: MatrixRecord): INTEGER;
  872.     {$IFC NOT GENERATINGCFM}
  873.     inline
  874.         $7014, $ABC2;
  875.     {$ENDC}
  876.     procedure CopyMatrix ({CONST}
  877.                                     var m1: MatrixRecord; var m2: MatrixRecord);
  878.     {$IFC NOT GENERATINGCFM}
  879.     inline
  880.         $7020, $ABC2;
  881.     {$ENDC}
  882.     function EqualMatrix ({CONST}
  883.                                     var m1: MatrixRecord; {CONST}
  884.                                     var m2: MatrixRecord): BOOLEAN;
  885.     {$IFC NOT GENERATINGCFM}
  886.     inline
  887.         $7021, $ABC2;
  888.     {$ENDC}
  889.     procedure SetIdentityMatrix (var matrix: MatrixRecord);
  890.     {$IFC NOT GENERATINGCFM}
  891.     inline
  892.         $7015, $ABC2;
  893.     {$ENDC}
  894.     procedure TranslateMatrix (var m: MatrixRecord; deltaH: Fixed; deltaV: Fixed);
  895.     {$IFC NOT GENERATINGCFM}
  896.     inline
  897.         $7019, $ABC2;
  898.     {$ENDC}
  899.     procedure RotateMatrix (var m: MatrixRecord; degrees: Fixed; aboutX: Fixed; aboutY: Fixed);
  900.     {$IFC NOT GENERATINGCFM}
  901.     inline
  902.         $7016, $ABC2;
  903.     {$ENDC}
  904.     procedure ScaleMatrix (var m: MatrixRecord; scaleX: Fixed; scaleY: Fixed; aboutX: Fixed; aboutY: Fixed);
  905.     {$IFC NOT GENERATINGCFM}
  906.     inline
  907.         $7017, $ABC2;
  908.     {$ENDC}
  909.     procedure SkewMatrix (var m: MatrixRecord; skewX: Fixed; skewY: Fixed; aboutX: Fixed; aboutY: Fixed);
  910.     {$IFC NOT GENERATINGCFM}
  911.     inline
  912.         $7018, $ABC2;
  913.     {$ENDC}
  914.     function TransformFixedPoints ({CONST}
  915.                                     var m: MatrixRecord; var fpt: FixedPoint; count: LONGINT): OSErr;
  916.     {$IFC NOT GENERATINGCFM}
  917.     inline
  918.         $7022, $ABC2;
  919.     {$ENDC}
  920.     function TransformPoints ({CONST}
  921.                                     var mp: MatrixRecord; var pt1: Point; count: LONGINT): OSErr;
  922.     {$IFC NOT GENERATINGCFM}
  923.     inline
  924.         $7023, $ABC2;
  925.     {$ENDC}
  926.     function TransformFixedRect ({CONST}
  927.                                     var m: MatrixRecord; var fr: FixedRect; var fpp: FixedPoint): BOOLEAN;
  928.     {$IFC NOT GENERATINGCFM}
  929.     inline
  930.         $7024, $ABC2;
  931.     {$ENDC}
  932.     function TransformRect ({CONST}
  933.                                     var m: MatrixRecord; var r: Rect; var fpp: FixedPoint): BOOLEAN;
  934.     {$IFC NOT GENERATINGCFM}
  935.     inline
  936.         $7025, $ABC2;
  937.     {$ENDC}
  938.     function InverseMatrix ({CONST}
  939.                                     var m: MatrixRecord; var im: MatrixRecord): BOOLEAN;
  940.     {$IFC NOT GENERATINGCFM}
  941.     inline
  942.         $701C, $ABC2;
  943.     {$ENDC}
  944.     procedure ConcatMatrix ({CONST}
  945.                                     var a: MatrixRecord; var b: MatrixRecord);
  946.     {$IFC NOT GENERATINGCFM}
  947.     inline
  948.         $701B, $ABC2;
  949.     {$ENDC}
  950.     procedure RectMatrix (var matrix: MatrixRecord; {CONST}
  951.                                     var srcRect: Rect; {CONST}
  952.                                     var dstRect: Rect);
  953.     {$IFC NOT GENERATINGCFM}
  954.     inline
  955.         $701E, $ABC2;
  956.     {$ENDC}
  957.     procedure MapMatrix (var matrix: MatrixRecord; {CONST}
  958.                                     var fromRect: Rect; {CONST}
  959.                                     var toRect: Rect);
  960.     {$IFC NOT GENERATINGCFM}
  961.     inline
  962.         $701D, $ABC2;
  963.     {$ENDC}
  964.  
  965. { $ALIGN RESET}
  966. { $POP}
  967.  
  968. {$ENDC}
  969.  {__IMAGECOMPRESSION__}
  970.  
  971. implementation
  972. end.
  973.